// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com

#include "../../include/javascript/IJavaScript.h"
#include "../../include/javascript/JS_Context.h"
#include "../../include/javascript/JS_Define.h"
#include "../../include/javascript/JS_EventHandler.h"
#include "../../include/javascript/JS_GlobalData.h"
#include "../../include/javascript/JS_Object.h"
#include "../../include/javascript/JS_Value.h"
#include "../../include/javascript/JavaScript.h"
#include "../../include/javascript/global.h"
#include "../../include/javascript/resource.h"

/* ---------------------------- global ---------------------------- */

// Helper class for compile-time calculation of hash values in order to
// avoid having global object initializers.
template <unsigned ACC, wchar_t... Ns>
struct CHash;

// Only needed to hash single-character strings.
template <wchar_t N>
struct CHash<N> {
  static const unsigned value = N;
};

template <unsigned ACC, wchar_t N>
struct CHash<ACC, N> {
  static const unsigned value = (ACC * 1313LLU + N) & 0xFFFFFFFF;
};

template <unsigned ACC, wchar_t N, wchar_t... Ns>
struct CHash<ACC, N, Ns...> {
  static const unsigned value = CHash<CHash<ACC, N>::value, Ns...>::value;
};

extern const unsigned int JSCONST_nStringHash =
  CHash<'s','t','r','i','n','g'>::value;
extern const unsigned int JSCONST_nNumberHash =
  CHash<'n','u','m','b','e','r'>::value;
extern const unsigned int JSCONST_nBoolHash =
  CHash<'b','o','o','l','e','a','n'>::value;
extern const unsigned int JSCONST_nDateHash =
  CHash<'d','a','t','e'>::value;
extern const unsigned int JSCONST_nObjectHash =
  CHash<'o','b','j','e','c','t'>::value;
extern const unsigned int JSCONST_nFXobjHash =
  CHash<'f','x','o','b','j'>::value;
extern const unsigned int JSCONST_nNullHash =
  CHash<'n','u','l','l'>::value;
extern const unsigned int JSCONST_nUndefHash =
  CHash<'u','n','d','e','f','i','n','e','d'>::value;

#ifdef _DEBUG
class HashVerify
{
public:
  HashVerify();
} g_hashVerify;

HashVerify::HashVerify()
{
  ASSERT(JSCONST_nStringHash ==
    JS_CalcHash(VALUE_NAME_STRING,wcslen(VALUE_NAME_STRING)));
  ASSERT(JSCONST_nNumberHash ==
    JS_CalcHash(VALUE_NAME_NUMBER,wcslen(VALUE_NAME_NUMBER)));
  ASSERT(JSCONST_nBoolHash ==
    JS_CalcHash(VALUE_NAME_BOOLEAN,wcslen(VALUE_NAME_BOOLEAN)));
  ASSERT(JSCONST_nDateHash ==
    JS_CalcHash(VALUE_NAME_DATE,wcslen(VALUE_NAME_DATE)));
  ASSERT(JSCONST_nObjectHash ==
    JS_CalcHash(VALUE_NAME_OBJECT,wcslen(VALUE_NAME_OBJECT)));
  ASSERT(JSCONST_nFXobjHash ==
    JS_CalcHash(VALUE_NAME_FXOBJ,wcslen(VALUE_NAME_FXOBJ)));
  ASSERT(JSCONST_nNullHash ==
    JS_CalcHash(VALUE_NAME_NULL,wcslen(VALUE_NAME_NULL)));
  ASSERT(JSCONST_nUndefHash ==
    JS_CalcHash(VALUE_NAME_UNDEFINED,wcslen(VALUE_NAME_UNDEFINED)));
}
#endif


BEGIN_JS_STATIC_CONST(CJS_Global)
END_JS_STATIC_CONST()

BEGIN_JS_STATIC_PROP(CJS_Global)
END_JS_STATIC_PROP()

BEGIN_JS_STATIC_METHOD(CJS_Global)
    JS_STATIC_METHOD_ENTRY(setPersistent)
END_JS_STATIC_METHOD()

IMPLEMENT_SPECIAL_JS_CLASS(CJS_Global, global_alternate, global);

FX_BOOL CJS_Global::InitInstance(IFXJS_Context* cc)
{
    CJS_Context* pContext = (CJS_Context*)cc;
    ASSERT(pContext != NULL);

    global_alternate* pGlobal = (global_alternate*)GetEmbedObject();
    ASSERT(pGlobal != NULL);

    pGlobal->Initial(pContext->GetReaderApp());

    return TRUE;
};

global_alternate::global_alternate(CJS_Object* pJSObject)
    : CJS_EmbedObj(pJSObject),
    m_pApp(NULL)
{
}

global_alternate::~global_alternate(void)
{
    DestroyGlobalPersisitentVariables();
    m_pApp->GetRuntimeFactory()->ReleaseGlobalData();
}

void global_alternate::Initial(CPDFDoc_Environment* pApp)
{
    m_pApp = pApp;
    m_pGlobalData = pApp->GetRuntimeFactory()->NewGlobalData(pApp);
    UpdateGlobalPersistentVariables();
}

FX_BOOL global_alternate::QueryProperty(const FX_WCHAR* propname)
{
    return CFX_WideString(propname) != L"setPersistent";
}

FX_BOOL global_alternate::DelProperty(IFXJS_Context* cc, const FX_WCHAR* propname, CFX_WideString& sError)
{
    js_global_data* pData = NULL;
    CFX_ByteString sPropName = CFX_ByteString::FromUnicode(propname);

    if (m_mapGlobal.Lookup(sPropName, (void*&)pData))
    {
        pData->bDeleted = TRUE;
        return TRUE;
    }

    return FALSE;
}

FX_BOOL global_alternate::DoProperty(IFXJS_Context* cc, const FX_WCHAR* propname, CJS_PropValue& vp, CFX_WideString& sError)
{
    if (vp.IsSetting())
    {
        CFX_ByteString sPropName = CFX_ByteString::FromUnicode(propname);
        switch (vp.GetType())
        {
        case VT_number:
            {
                double dData;
                vp >> dData;
                return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_NUMBER, dData, false, "", v8::Local<v8::Object>(), FALSE);
            }
        case VT_boolean:
            {
                bool bData;
                vp >> bData;
                return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_BOOLEAN, 0, bData, "", v8::Local<v8::Object>(), FALSE);
            }
        case VT_string:
            {
                CFX_ByteString sData;
                vp >> sData;
                return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_STRING, 0, false, sData, v8::Local<v8::Object>(), FALSE);
            }
        case VT_object:
            {
                JSObject pData;
                vp >> pData;
                return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_OBJECT, 0, false, "", pData, FALSE);
            }
        case VT_null:
            {
                return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_NULL, 0, false, "", v8::Local<v8::Object>(), FALSE);
            }
        case VT_undefined:
            {
                DelProperty(cc, propname, sError);
                return TRUE;
            }
        default:
            break;
        }
    }
    else
    {
        void* pVoid = nullptr;
        if (!m_mapGlobal.Lookup(CFX_ByteString::FromUnicode(propname), pVoid))
        {
            vp.SetNull();
            return TRUE;
        }
        if (!pVoid)
        {
            vp.SetNull();
            return TRUE;
        }
        js_global_data* pData = (js_global_data*)pVoid;
        if (pData->bDeleted)
            return TRUE;

        switch (pData->nType)
        {
            case JS_GLOBALDATA_TYPE_NUMBER:
                vp << pData->dData;
                return TRUE;
            case JS_GLOBALDATA_TYPE_BOOLEAN:
                vp << pData->bData;
                return TRUE;
            case JS_GLOBALDATA_TYPE_STRING:
                vp << pData->sData;
                return TRUE;
            case JS_GLOBALDATA_TYPE_OBJECT:
                {
                    v8::Local<v8::Object> obj = v8::Local<v8::Object>::New(vp.GetIsolate(),pData->pData);
                    vp << obj;
                    return TRUE;
                }
            case JS_GLOBALDATA_TYPE_NULL:
                vp.SetNull();
                return TRUE;
            default:
                break;
        }
    }
    return FALSE;
}

FX_BOOL global_alternate::setPersistent(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
{
    CJS_Context* pContext = static_cast<CJS_Context*>(cc);
    if (params.size() != 2)
    {
        sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
        return FALSE;
    }

    CFX_ByteString sName = params[0].ToCFXByteString();

    js_global_data* pData = NULL;
    if (m_mapGlobal.Lookup(sName, (void*&)pData))
    {
        if (pData && !pData->bDeleted)
        {
            pData->bPersistent = params[1].ToBool();
            return TRUE;
        }
    }

    sError = JSGetStringFromID(pContext, IDS_STRING_JSNOGLOBAL);
    return FALSE;
}

void global_alternate::UpdateGlobalPersistentVariables()
{
    ASSERT(m_pGlobalData != NULL);

    for (int i=0,sz=m_pGlobalData->GetSize(); i<sz; i++)
    {
        CJS_GlobalData_Element* pData = m_pGlobalData->GetAt(i);
        ASSERT(pData != NULL);

        switch (pData->data.nType)
        {
        case JS_GLOBALDATA_TYPE_NUMBER:
            SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_NUMBER, pData->data.dData, false, "", v8::Local<v8::Object>(), pData->bPersistent == 1);
            JS_PutObjectNumber(NULL,(JSFXObject)(*m_pJSObject),
                               pData->data.sKey.UTF8Decode().c_str(), pData->data.dData);
            break;
        case JS_GLOBALDATA_TYPE_BOOLEAN:
            SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_BOOLEAN, 0, (bool)(pData->data.bData == 1), "", v8::Local<v8::Object>(), pData->bPersistent == 1);
            JS_PutObjectBoolean(NULL,(JSFXObject)(*m_pJSObject),
                                pData->data.sKey.UTF8Decode().c_str(), (bool)(pData->data.bData == 1));
            break;
        case JS_GLOBALDATA_TYPE_STRING:
            SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_STRING, 0, false, pData->data.sData, v8::Local<v8::Object>(), pData->bPersistent == 1);
            JS_PutObjectString(NULL, (JSFXObject)(*m_pJSObject),
                               pData->data.sKey.UTF8Decode().c_str(),
                               pData->data.sData.UTF8Decode().c_str());
            break;
        case JS_GLOBALDATA_TYPE_OBJECT:
            {
                IJS_Runtime* pRuntime = JS_GetRuntime((JSFXObject)(*m_pJSObject));
                v8::Local<v8::Object> pObj = JS_NewFxDynamicObj(pRuntime, NULL, -1);

                PutObjectProperty(pObj, &pData->data);

                SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_OBJECT, 0, false, "",
                    (JSObject)pObj, pData->bPersistent == 1);
                JS_PutObjectObject(NULL,(JSFXObject)(*m_pJSObject),
                                   pData->data.sKey.UTF8Decode().c_str(), (JSObject)pObj);
            }
            break;
        case JS_GLOBALDATA_TYPE_NULL:
            SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_NULL, 0, false, "", v8::Local<v8::Object>(), pData->bPersistent == 1);
            JS_PutObjectNull(NULL,(JSFXObject)(*m_pJSObject),
                             pData->data.sKey.UTF8Decode().c_str());
            break;
        }
    }
}

void global_alternate::CommitGlobalPersisitentVariables()
{
    ASSERT(m_pGlobalData != NULL);

    FX_POSITION  pos = m_mapGlobal.GetStartPosition();
    while (pos)
    {
        CFX_ByteString name;
        js_global_data* pData = NULL;
        m_mapGlobal.GetNextAssoc(pos, name, (void*&)pData);

        if (pData)
        {
            if (pData->bDeleted)
            {
                m_pGlobalData->DeleteGlobalVariable(name);
            }
            else
            {
                switch (pData->nType)
                {
                case JS_GLOBALDATA_TYPE_NUMBER:
                    m_pGlobalData->SetGlobalVariableNumber(name, pData->dData);
                    m_pGlobalData->SetGlobalVariablePersistent(name, pData->bPersistent);
                    break;
                case JS_GLOBALDATA_TYPE_BOOLEAN:
                    m_pGlobalData->SetGlobalVariableBoolean(name, pData->bData);
                    m_pGlobalData->SetGlobalVariablePersistent(name, pData->bPersistent);
                    break;
                case JS_GLOBALDATA_TYPE_STRING:
                    m_pGlobalData->SetGlobalVariableString(name, pData->sData);
                    m_pGlobalData->SetGlobalVariablePersistent(name, pData->bPersistent);
                    break;
                case JS_GLOBALDATA_TYPE_OBJECT:
                    //if (pData->pData)
                    {
                        CJS_GlobalVariableArray array;
                        v8::Local<v8::Object> obj = v8::Local<v8::Object>::New(GetJSObject()->GetIsolate(),pData->pData);
                        ObjectToArray(obj, array);
                        m_pGlobalData->SetGlobalVariableObject(name, array);
                        m_pGlobalData->SetGlobalVariablePersistent(name, pData->bPersistent);
                    }
                    break;
                case JS_GLOBALDATA_TYPE_NULL:
                    m_pGlobalData->SetGlobalVariableNull(name);
                    m_pGlobalData->SetGlobalVariablePersistent(name, pData->bPersistent);
                    break;
                }
            }
        }
    }
}

void global_alternate::ObjectToArray(v8::Local<v8::Object> pObj, CJS_GlobalVariableArray& array)
{
    v8::Local<v8::Context> context = pObj->CreationContext();
    v8::Isolate* isolate = context->GetIsolate();
    v8::Local<v8::Array> pKeyList = JS_GetObjectElementNames(isolate, pObj);
    int nObjElements = pKeyList->Length();

    for (int i=0; i<nObjElements; i++)
    {

        CFX_WideString ws = JS_ToString(isolate, JS_GetArrayElement(isolate, pKeyList, i));
        CFX_ByteString sKey = ws.UTF8Encode();

        v8::Local<v8::Value> v = JS_GetObjectElement(isolate, pObj, ws.c_str());
        FXJSVALUETYPE vt = GET_VALUE_TYPE(v);
        switch (vt)
        {
        case VT_number:
            {
                CJS_KeyValue* pObjElement = new CJS_KeyValue;
                pObjElement->nType = JS_GLOBALDATA_TYPE_NUMBER;
                pObjElement->sKey = sKey;
                pObjElement->dData = JS_ToNumber(isolate, v);
                array.Add(pObjElement);
            }
            break;
        case VT_boolean:
            {
                CJS_KeyValue* pObjElement = new CJS_KeyValue;
                pObjElement->nType = JS_GLOBALDATA_TYPE_BOOLEAN;
                pObjElement->sKey = sKey;
                pObjElement->dData = JS_ToBoolean(isolate, v);
                array.Add(pObjElement);
            }
            break;
        case VT_string:
            {
                CFX_ByteString sValue = CJS_Value(isolate, v, VT_string).ToCFXByteString();
                CJS_KeyValue* pObjElement = new CJS_KeyValue;
                pObjElement->nType = JS_GLOBALDATA_TYPE_STRING;
                pObjElement->sKey = sKey;
                pObjElement->sData = sValue;
                array.Add(pObjElement);
            }
            break;
        case VT_object:
            {
                CJS_KeyValue* pObjElement = new CJS_KeyValue;
                pObjElement->nType = JS_GLOBALDATA_TYPE_OBJECT;
                pObjElement->sKey = sKey;
                ObjectToArray(JS_ToObject(isolate, v), pObjElement->objData);
                array.Add(pObjElement);
            }
            break;
        case VT_null:
            {
                CJS_KeyValue* pObjElement = new CJS_KeyValue;
                pObjElement->nType = JS_GLOBALDATA_TYPE_NULL;
                pObjElement->sKey = sKey;
                array.Add(pObjElement);
            }
            break;
        default:
            break;
        }
    }
}

void global_alternate::PutObjectProperty(v8::Local<v8::Object> pObj, CJS_KeyValue* pData)
{
    ASSERT(pData != NULL);

    for (int i=0,sz=pData->objData.Count(); i<sz; i++)
    {
        CJS_KeyValue* pObjData = pData->objData.GetAt(i);
        ASSERT(pObjData != NULL);

        switch (pObjData->nType)
        {
        case JS_GLOBALDATA_TYPE_NUMBER:
            JS_PutObjectNumber(NULL,(JSObject)pObj, pObjData->sKey.UTF8Decode().c_str(), pObjData->dData);
            break;
        case JS_GLOBALDATA_TYPE_BOOLEAN:
            JS_PutObjectBoolean(NULL,(JSObject)pObj, pObjData->sKey.UTF8Decode().c_str(), (bool)(pObjData->bData == 1));
            break;
        case JS_GLOBALDATA_TYPE_STRING:
            JS_PutObjectString(NULL,(JSObject)pObj, pObjData->sKey.UTF8Decode().c_str(), pObjData->sData.UTF8Decode().c_str());
            break;
        case JS_GLOBALDATA_TYPE_OBJECT:
            {
                IJS_Runtime* pRuntime = JS_GetRuntime((JSFXObject)(*m_pJSObject));
                v8::Local<v8::Object> pNewObj = JS_NewFxDynamicObj(pRuntime, NULL, -1);
                PutObjectProperty(pNewObj, pObjData);
                JS_PutObjectObject(NULL, (JSObject)pObj, pObjData->sKey.UTF8Decode().c_str(), (JSObject)pNewObj);
            }
            break;
        case JS_GLOBALDATA_TYPE_NULL:
            JS_PutObjectNull(NULL,(JSObject)pObj, pObjData->sKey.UTF8Decode().c_str());
            break;
        }
    }
}

void global_alternate::DestroyGlobalPersisitentVariables()
{
    FX_POSITION  pos = m_mapGlobal.GetStartPosition();
    while (pos)
    {
        CFX_ByteString name;
        js_global_data* pData = NULL;
        m_mapGlobal.GetNextAssoc(pos, name, (void*&)pData);
        delete pData;
    }

    m_mapGlobal.RemoveAll();
}


FX_BOOL global_alternate::SetGlobalVariables(const FX_CHAR* propname, int nType,
                double dData, bool bData, const CFX_ByteString& sData, JSObject pData, bool bDefaultPersistent)
{
    if (propname == NULL) return FALSE;

    js_global_data* pTemp = NULL;
    m_mapGlobal.Lookup(propname, (void*&)pTemp);

    if (pTemp)
    {
        if (pTemp->bDeleted || pTemp->nType != nType)
        {
            pTemp->dData = 0;
            pTemp->bData = 0;
            pTemp->sData = "";
            pTemp->nType = nType;
        }

        pTemp->bDeleted = FALSE;

        switch (nType)
        {
        case JS_GLOBALDATA_TYPE_NUMBER:
            {
                pTemp->dData = dData;
            }
            break;
        case JS_GLOBALDATA_TYPE_BOOLEAN:
            {
                pTemp->bData = bData;
            }
            break;
        case JS_GLOBALDATA_TYPE_STRING:
            {
                pTemp->sData = sData;
            }
            break;
        case JS_GLOBALDATA_TYPE_OBJECT:
            {
                pTemp->pData.Reset(JS_GetRuntime(pData), pData);
            }
            break;
        case JS_GLOBALDATA_TYPE_NULL:
            break;
        default:
            return FALSE;
        }

        return TRUE;
    }

    js_global_data* pNewData = NULL;

    switch (nType)
    {
    case JS_GLOBALDATA_TYPE_NUMBER:
        {
            pNewData = new js_global_data;
            pNewData->nType = JS_GLOBALDATA_TYPE_NUMBER;
            pNewData->dData = dData;
            pNewData->bPersistent = bDefaultPersistent;
        }
        break;
    case JS_GLOBALDATA_TYPE_BOOLEAN:
        {
            pNewData = new js_global_data;
            pNewData->nType = JS_GLOBALDATA_TYPE_BOOLEAN;
            pNewData->bData = bData;
            pNewData->bPersistent = bDefaultPersistent;
        }
        break;
    case JS_GLOBALDATA_TYPE_STRING:
        {
            pNewData = new js_global_data;
            pNewData->nType = JS_GLOBALDATA_TYPE_STRING;
            pNewData->sData = sData;
            pNewData->bPersistent = bDefaultPersistent;
        }
        break;
    case JS_GLOBALDATA_TYPE_OBJECT:
        {
            pNewData = new js_global_data;
            pNewData->nType = JS_GLOBALDATA_TYPE_OBJECT;
            pNewData->pData.Reset(JS_GetRuntime(pData), pData);
            pNewData->bPersistent = bDefaultPersistent;
        }
        break;
    case JS_GLOBALDATA_TYPE_NULL:
        {
            pNewData = new js_global_data;
            pNewData->nType = JS_GLOBALDATA_TYPE_NULL;
            pNewData->bPersistent = bDefaultPersistent;
        }
        break;
    default:
        return FALSE;
    }

    m_mapGlobal.SetAt(propname, (void*)pNewData);

    return TRUE;
}

FXJSVALUETYPE GET_VALUE_TYPE(v8::Local<v8::Value> p)
{
  const unsigned int nHash = JS_CalcHash(JS_GetTypeof(p));

  if (nHash == JSCONST_nUndefHash)
    return VT_undefined;
  if (nHash == JSCONST_nNullHash)
    return VT_null;
  if (nHash == JSCONST_nStringHash)
    return VT_string;
  if (nHash == JSCONST_nNumberHash)
    return VT_number;
  if (nHash == JSCONST_nBoolHash)
    return VT_boolean;
  if (nHash == JSCONST_nDateHash)
    return VT_date;
  if (nHash == JSCONST_nObjectHash)
    return VT_object;
  if (nHash == JSCONST_nFXobjHash)
    return VT_fxobject;

  return VT_unknown;
}
